(function(){
  'use strict';

  if (!window.Api) return;

  var container = document.getElementById('broadcast');
  if (!container) {
    console.log('广播模块: 未找到广播容器');
    return;
  }
  console.log('广播模块: 找到广播容器，开始初始化');

  // 获取交易所显示名称的函数
  function getExchangeDisplayName(exchangeId) {
    var exchanges = {
      'gate_io': '芝麻开门现货 (Gate.io)',
      'gate_io_perpetual': '芝麻开门合约 (Gate.io Perpetual)',
      'binance': '币安现货 (Binance)',
      'binance_perpetual': '币安合约 (Binance Perpetual)',
      'binance_us': '币安美国 (Binance US)',
      'okx': '欧易现货 (OKX)',
      'okx_perpetual': '欧易合约 (OKX Perpetual)',
      'huobi': '火币现货 (Huobi)',
      'htx': '火币HTX (HTX)',
      'huobi_perpetual': '火币合约 (Huobi Perpetual)',
      'bybit': 'Bybit现货 (Bybit)',
      'bybit_perpetual': 'Bybit合约 (Bybit Perpetual)',
      'kraken': '海妖现货 (Kraken)',
      'kraken_perpetual': '海妖合约 (Kraken Perpetual)',
      'coinbase': 'Coinbase现货 (Coinbase)',
      'coinbase_perpetual': 'Coinbase合约 (Coinbase Perpetual)',
      'kucoin': '库币现货 (KuCoin)',
      'kucoin_perpetual': '库币合约 (KuCoin Perpetual)',
      'mexc': '抹茶现货 (MEXC)',
      'bingx': '必应现货 (BingX)',
      'bing_x': '必应现货 (BingX)',
      'bitmart': '比特玛特现货 (BitMart)',
      'bitget': 'Bitget现货 (Bitget)',
      'ascendex': 'AscendEX现货 (AscendEX)',
      'ascend_ex': 'AscendEX合约 (AscendEX Perpetual)',
      'crypto_com': 'Crypto.com现货 (Crypto.com)',
      'vertex': 'Vertex现货 (Vertex)',
      'injective': 'Injective现货 (Injective)',
      'injective_v2': 'Injective V2现货 (Injective V2)',
      'hyperliquid': 'Hyperliquid现货 (Hyperliquid)'
    };
    return exchanges[exchangeId] || exchangeId;
  }

  var listWrap = document.getElementById('broadcast-list');
  var joinedListWrap = document.getElementById('joined-groups-list');
  console.log('广播列表容器:', listWrap);
  console.log('已加入分组容器:', joinedListWrap);
  if (!listWrap) {
    console.error('未找到广播列表容器 #broadcast-list');
  }
  if (!joinedListWrap) {
    console.error('未找到已加入分组容器 #joined-groups-list');
  }
  function renderError(msg){ if (!listWrap) return; listWrap.innerHTML = '<p class="muted">' + msg + '</p>'; }
  function renderJoinedError(msg){ if (!joinedListWrap) return; joinedListWrap.innerHTML = '<p class="muted">' + msg + '</p>'; }
  
  // 立即从已加入分组列表中移除指定分组
  function removeGroupFromJoinedList(groupId) {
    if (!joinedListWrap) return;
    
    console.log('查找要移除的分组ID:', groupId);
    var cards = joinedListWrap.querySelectorAll('.card');
    console.log('已加入分组卡片数量:', cards.length);
    
    // 方法1：通过按钮的data-group-id属性匹配
    for (var i = 0; i < cards.length; i++) {
      var card = cards[i];
      var leaveBtn = card.querySelector('button[data-group-id]');
      if (leaveBtn) {
        var btnGroupId = leaveBtn.getAttribute('data-group-id');
        var btnGroupName = leaveBtn.getAttribute('data-group-name');
        console.log('检查按钮分组ID:', btnGroupId, '分组名称:', btnGroupName);
        
        if (btnGroupId == groupId) {
          console.log('通过data属性匹配找到分组卡片:', btnGroupName);
          card.remove();
          console.log('分组卡片已移除');
          return;
        }
      }
    }
    
    // 方法2：通过按钮的onclick事件匹配（备用方法）
    console.log('尝试通过onclick事件匹配...');
    for (var i = 0; i < cards.length; i++) {
      var card = cards[i];
      var leaveBtn = card.querySelector('button');
      if (leaveBtn && leaveBtn.onclick) {
        try {
          var onclickStr = leaveBtn.onclick.toString();
          console.log('按钮onclick字符串:', onclickStr);
          
          if (onclickStr.includes('leaveGroup(' + groupId + ',')) {
            console.log('通过onclick匹配找到分组卡片');
            card.remove();
            console.log('分组卡片已移除');
            return;
          }
        } catch (e) {
          console.log('检查onclick时出错:', e);
        }
      }
    }
    
    console.log('未找到要移除的分组卡片');
  }

  // 立即从广播分组列表中移除指定分组
  function removeGroupFromBroadcastList(groupId) {
    if (!listWrap) return;
    
    console.log('从广播分组列表中查找要移除的分组ID:', groupId);
    var cards = listWrap.querySelectorAll('.card');
    console.log('广播分组卡片数量:', cards.length);
    
    // 通过按钮的onclick函数匹配分组ID
    for (var i = 0; i < cards.length; i++) {
      var card = cards[i];
      var joinBtn = card.querySelector('button');
      if (joinBtn && joinBtn.textContent === '加入分组') {
        // 检查按钮的onclick函数是否包含该分组ID
        var onclickStr = joinBtn.onclick.toString();
        if (onclickStr.includes(groupId)) {
          console.log('找到要移除的广播分组卡片:', groupId);
          card.remove();
          console.log('已移除广播分组卡片:', groupId);
          return;
        }
      }
    }
    
    console.log('未找到要移除的广播分组卡片:', groupId);
  }

  async function loadGroups(){
    if (!listWrap) return;
    
    // 检查是否在广播页面
    if (!isBroadcastActive()) {
      console.log('广播模块: 不在广播页面，跳过加载');
      return;
    }
    
    listWrap.innerHTML = '<p class="muted">加载中...</p>';
    try {
      console.log('加载用户广播分组...');
      
      // 获取用户信息
      var userInfo = await window.Api.jsonOrThrow(await window.Api.request('GET','/auth/me',null,true));
      console.log('用户信息:', userInfo);
      
      // 使用普通用户接口 - 根据API文档
      var res = await window.Api.request('GET','/broadcast/groups',null,true);
      console.log('用户广播分组API响应状态:', res.status, res.ok);
      var data = await window.Api.jsonOrThrow(res);
      console.log('用户广播分组数据:', data);
      console.log('数据类型:', typeof data);
      console.log('数据是否为数组:', Array.isArray(data));
      console.log('数据键名:', data ? Object.keys(data) : '无数据');
      
      var allGroups = Array.isArray(data) ? data : (data && data.items) || [];
      console.log('所有广播分组:', allGroups);
      console.log('分组数量:', allGroups.length);
      
      // 检查用户已加入的分组 - 使用正确的API逻辑
      var joinedGroupIds = [];
      var exitedGroups = window.exitedGroups || [];
      console.log('已退出的分组ID:', exitedGroups);
      
      // 使用API返回的joined字段判断是否已加入
      for (var i = 0; i < allGroups.length; i++) {
        var group = allGroups[i];
        console.log('检查分组', group.id, '详细信息:', group);
        console.log('分组', group.id, 'joined字段:', group.joined);
        
        // 跳过已退出的分组
        if (exitedGroups.includes(group.id)) {
          console.log('跳过已退出的分组:', group.id, group.name);
          continue;
        }
        
        // 使用API返回的joined字段判断是否已加入
        console.log('分组', group.id, 'joined字段类型:', typeof group.joined);
        console.log('分组', group.id, 'joined字段值:', group.joined);
        console.log('分组', group.id, 'joined === true:', group.joined === true);
        console.log('分组', group.id, 'joined == true:', group.joined == true);
        
        if (group.joined === true || group.joined === 'true' || group.joined === 1) {
          console.log('用户已加入分组:', group.id, group.name);
          joinedGroupIds.push(group.id);
        } else {
          console.log('用户未加入分组:', group.id, group.name);
        }
      }
      
      console.log('用户已加入的分组ID:', joinedGroupIds);
      console.log('=== 分组状态检测完成 ===');
      
      // 禁用自动加入分组功能 - 避免不必要的400错误请求
      console.log('自动加入分组功能已禁用，避免不必要的API请求');
      console.log('用户可以通过界面手动加入分组');
      
      // 移除错误的检查逻辑 - 不再使用POST请求来检查状态
      console.log('=== 使用正确的API逻辑完成 ===');
      
      console.log('=== 分组状态检测完成 ===');
      console.log('所有分组:', allGroups.map(function(g) { return g.id + ':' + g.name; }));
      console.log('已加入分组ID:', joinedGroupIds);
      
      console.log('用户已加入的分组ID:', joinedGroupIds);
      
      // 过滤掉已加入的分组
      console.log('开始过滤分组...');
      console.log('所有分组数量:', allGroups.length);
      console.log('已加入分组ID列表:', joinedGroupIds);
      
      var availableGroups = allGroups.filter(function(group) {
        var isJoined = joinedGroupIds.includes(group.id);
        console.log('分组', group.id, '是否已加入:', isJoined);
        return !isJoined;
      });
      
      console.log('可加入的广播分组:', availableGroups);
      console.log('可加入分组数量:', availableGroups.length);
      
      if (!availableGroups.length){ 
        listWrap.innerHTML = '<p class="muted">暂无可加入的广播组</p>'; 
        return; 
      }
      
      listWrap.innerHTML = '';
      availableGroups.forEach(function(g){
        var card = document.createElement('section'); 
        card.className='card';
        
        var title = document.createElement('h3'); 
        title.className='card-title'; 
        title.textContent = g.name || g.id || '广播组'; 
        card.appendChild(title);
        
        var info = document.createElement('div'); 
        info.className='small muted';
        var parts = [];
        if (g.description) parts.push(g.description);
        if (g.created_at) parts.push('创建于 ' + g.created_at);
        if (g.status) parts.push('状态 ' + g.status);
        if (g.connector_name) {
          // 使用用户友好的交易所显示名称
          var displayName = getExchangeDisplayName(g.connector_name);
          parts.push('交易所: ' + displayName);
        }
        info.textContent = parts.join(' · ');
        card.appendChild(info);
        
        // 添加加入/退出按钮
        var actions = document.createElement('div');
        actions.style.marginTop = '12px';
        actions.style.display = 'flex';
        actions.style.gap = '8px';
        
        var joinBtn = document.createElement('button');
        joinBtn.className = 'btn primary';
        joinBtn.textContent = '加入分组';
        joinBtn.onclick = function() { joinGroup(g.id, g.name, g.connector_name); };
        actions.appendChild(joinBtn);
        
        var leaveBtn = document.createElement('button');
        leaveBtn.className = 'btn';
        leaveBtn.textContent = '退出分组';
        leaveBtn.onclick = function() { leaveGroup(g.id, g.name); };
        actions.appendChild(leaveBtn);
        
        card.appendChild(actions);
        listWrap.appendChild(card);
        console.log('添加可加入广播组:', g.name || g.id);
        console.log('卡片已添加到DOM:', card);
        console.log('列表容器子元素数量:', listWrap.children.length);
      });
    } catch (err) {
      console.log('用户广播组加载失败:', err);
      renderError('广播组加载失败：' + (err && err.message ? err.message : '未知错误'));
    }
  }

  // 加载已加入的分组
  async function loadJoinedGroups(){
    if (!joinedListWrap) return;
    
    // 检查是否在广播页面
    if (!isBroadcastActive()) {
      console.log('广播模块: 不在广播页面，跳过加载已加入分组');
      return;
    }
    
    joinedListWrap.innerHTML = '<p class="muted">加载中...</p>';
    try {
      console.log('加载已加入分组...');
      
      // 获取用户信息
      var userInfo = await window.Api.jsonOrThrow(await window.Api.request('GET','/auth/me',null,true));
      console.log('用户信息:', userInfo);
      
      // 获取用户绑定的交易所账户
      var accountsResp = await window.Api.request('GET','/users/accounts',null,true);
      var accountsData = await window.Api.jsonOrThrow(accountsResp);
      console.log('用户账户信息:', accountsData);
      
      // 获取所有广播分组
      var res = await window.Api.request('GET','/broadcast/groups',null,true);
      console.log('获取所有广播分组API响应状态:', res.status, res.ok);
      var allGroups = await window.Api.jsonOrThrow(res);
      console.log('所有广播分组数据:', allGroups);
      
      var groups = Array.isArray(allGroups) ? allGroups : (allGroups && allGroups.items) || [];
      console.log('处理后的所有广播分组:', groups);
      
      // 由于 /members 接口返回404，我们使用另一种方法：
      // 使用正确的API逻辑 - 直接检查joined字段
      var joinedGroups = [];
      
      for (var i = 0; i < groups.length; i++) {
        var group = groups[i];
        console.log('检查分组', group.id, 'joined字段:', group.joined);
        
        // 使用API返回的joined字段判断是否已加入
        if (group.joined === true) {
          joinedGroups.push(group);
          console.log('用户已加入分组:', group.name || group.id);
        } else {
          console.log('用户未加入分组:', group.name || group.id);
        }
      }
      
      console.log('用户已加入的分组:', joinedGroups);
      
      if (!joinedGroups.length){ 
        joinedListWrap.innerHTML = '<p class="muted">您还没有加入任何广播分组</p>'; 
        return; 
      }
      
      joinedListWrap.innerHTML = '';
      joinedGroups.forEach(function(g){
        var card = document.createElement('section'); 
        card.className='card';
        
        var title = document.createElement('h3'); 
        title.className='card-title'; 
        title.textContent = g.name || g.id || '广播组'; 
        card.appendChild(title);
        
        var info = document.createElement('div'); 
        info.className='small muted';
        var parts = [];
        if (g.description) parts.push(g.description);
        if (g.created_at) parts.push('创建于 ' + g.created_at);
        if (g.status) parts.push('状态 ' + g.status);
        if (g.connector_name) {
          // 使用用户友好的交易所显示名称
          var displayName = getExchangeDisplayName(g.connector_name);
          parts.push('交易所: ' + displayName);
        }
        info.textContent = parts.join(' · ');
        card.appendChild(info);
        
        // 添加退出按钮
        var actions = document.createElement('div');
        actions.style.marginTop = '12px';
        actions.style.display = 'flex';
        actions.style.gap = '8px';
        
        var leaveBtn = document.createElement('button');
        leaveBtn.className = 'btn';
        leaveBtn.textContent = '退出分组';
        leaveBtn.setAttribute('data-group-id', g.id);
        leaveBtn.setAttribute('data-group-name', g.name);
        leaveBtn.onclick = function() { leaveGroup(g.id, g.name); };
        actions.appendChild(leaveBtn);
        
        card.appendChild(actions);
        joinedListWrap.appendChild(card);
        console.log('添加已加入分组:', g.name || g.id);
      });
    } catch (err) {
      console.log('已加入分组加载失败:', err);
      renderJoinedError('已加入分组加载失败：' + (err && err.message ? err.message : '未知错误'));
    }
  }

  // 加入广播分组
  async function joinGroup(groupId, groupName, connectorName) {
    try {
      console.log('加入广播分组:', groupId, groupName, connectorName);
      
      // 检查用户是否已绑定交易所
      var userInfo = await window.Api.jsonOrThrow(await window.Api.request('GET','/auth/me',null,true));
      console.log('用户信息:', userInfo);
      
      // 获取用户绑定的交易所
      var accountsResp = await window.Api.request('GET','/users/accounts',null,true);
      var accountsData = await window.Api.jsonOrThrow(accountsResp);
      console.log('用户账户信息:', accountsData);
      
      // 使用传入的connector_name，如果没有则使用默认值
      var finalConnectorName = connectorName || 'gate_io';
      console.log('使用的连接器名称:', finalConnectorName);
      
      // 构建加入分组的请求体 - 尝试不同的参数格式
      var joinPayload = {
        account_name: userInfo.email || 'default_account',
        connector_name: finalConnectorName
      };
      
      // 检查参数是否为空或无效
      if (!joinPayload.account_name || joinPayload.account_name === 'default_account') {
        console.log('警告: account_name 可能无效:', joinPayload.account_name);
      }
      if (!joinPayload.connector_name) {
        console.log('警告: connector_name 为空');
      }
      
      console.log('加入分组请求体:', joinPayload);
      console.log('分组ID:', groupId);
      console.log('API路径:', '/broadcast/groups/' + groupId + '/join');
      
      var res = await window.Api.request('POST', '/broadcast/groups/' + groupId + '/join', joinPayload, true);
      console.log('加入分组API响应状态:', res.status, res.ok);
      
      if (!res.ok) {
        console.log('API响应失败，状态码:', res.status);
        var errorText = await res.text();
        console.log('错误响应内容:', errorText);
        
        // 检查是否是"已加入该分组"的错误
        if (res.status === 400 && errorText.includes('已加入该分组')) {
          alert('您已经加入了该广播分组: ' + groupName);
          // 重新加载分组列表和已加入分组
          loadGroups();
          loadJoinedGroups();
          return;
        }
        
        // 检查是否是"未绑定该交易所"的错误
        if (res.status === 400 && errorText.includes('未绑定该交易所')) {
          alert('请先绑定 ' + connectorName + ' 交易所，然后才能加入该分组');
          return;
        }
        
        throw new Error('API请求失败: ' + res.status + ' - ' + errorText);
      }
      
      var data = await window.Api.jsonOrThrow(res);
      console.log('加入分组成功:', data);
      alert('成功加入广播分组: ' + groupName);
      
      // 立即从广播分组列表中移除该分组
      console.log('立即从广播分组列表中移除分组:', groupId);
      removeGroupFromBroadcastList(groupId);
      
      // 重新加载分组列表和已加入分组
      console.log('加入分组成功，刷新所有列表...');
      setTimeout(function() {
        console.log('开始重新加载所有分组列表...');
        loadGroups();
        loadJoinedGroups();
      }, 300);
    } catch (err) {
      console.log('加入分组失败:', err);
      console.log('错误详情:', err.message, err.status);
      alert('加入分组失败: ' + (err && err.message ? err.message : '未知错误'));
    }
  }

  // 退出广播分组
  async function leaveGroup(groupId, groupName) {
    try {
      console.log('退出广播分组:', groupId, groupName);
      
      // 获取用户信息
      var userInfo = await window.Api.jsonOrThrow(await window.Api.request('GET','/auth/me',null,true));
      console.log('用户信息:', userInfo);
      
      // 尝试不同的API路径和参数格式
      var leavePayload = {
        account_name: userInfo.email || 'default_account'
      };
      
      console.log('退出分组请求体:', leavePayload);
      console.log('尝试API路径: /broadcast/groups/' + groupId + '/leave');
      
      var res = await window.Api.request('DELETE', '/broadcast/groups/' + groupId + '/leave', leavePayload, true);
      console.log('退出分组API响应状态:', res.status, res.ok);
      
      if (!res.ok) {
        console.log('API响应失败，状态码:', res.status);
        var errorText = await res.text();
        console.log('错误响应内容:', errorText);
        
        // 如果是404错误，尝试其他API路径
        if (res.status === 404) {
          console.log('尝试其他API路径...');
          // 尝试不带参数的DELETE请求
          var res2 = await window.Api.request('DELETE', '/broadcast/groups/' + groupId + '/leave', null, true);
          console.log('第二次尝试API响应状态:', res2.status, res2.ok);
          
          if (res2.ok) {
            var data = await window.Api.jsonOrThrow(res2);
            console.log('退出分组成功:', data);
            console.log('=== 退出分组API调用成功（第二次尝试）===');
            alert('成功退出广播分组: ' + groupName);
            
            // 立即从界面中移除该分组
            console.log('立即从界面中移除分组:', groupId);
            removeGroupFromJoinedList(groupId);
            
            // 标记该分组已退出，避免重新加入
            console.log('标记分组已退出，避免重新检测:', groupId);
            window.exitedGroups = window.exitedGroups || [];
            window.exitedGroups.push(groupId);
            
            // 立即从广播分组列表中重新显示该分组
            console.log('退出分组成功，立即刷新广播分组列表...');
            setTimeout(function() {
              console.log('开始重新加载广播分组列表...');
              loadGroups();
              // 重新加载已加入分组列表
              loadJoinedGroups();
            }, 300);
            return;
          } else {
            var errorText2 = await res2.text();
            console.log('第二次尝试错误响应内容:', errorText2);
            throw new Error('API请求失败: ' + res2.status + ' - ' + errorText2);
          }
        }
        
        throw new Error('API请求失败: ' + res.status + ' - ' + errorText);
      }
      
      var data = await window.Api.jsonOrThrow(res);
      console.log('退出分组成功:', data);
      console.log('=== 退出分组API调用成功 ===');
      alert('成功退出广播分组: ' + groupName);
      
      // 立即从界面中移除该分组
      console.log('立即从界面中移除分组:', groupId);
      removeGroupFromJoinedList(groupId);
      
      // 标记该分组已退出，避免重新加入
      console.log('标记分组已退出，避免重新检测:', groupId);
      window.exitedGroups = window.exitedGroups || [];
      window.exitedGroups.push(groupId);
      
      // 立即从广播分组列表中重新显示该分组
      console.log('退出分组成功，立即刷新广播分组列表...');
      setTimeout(function() {
        console.log('开始重新加载广播分组列表...');
        loadGroups();
        // 重新加载已加入分组列表
        loadJoinedGroups();
      }, 300);
    } catch (err) {
      console.log('退出分组失败:', err);
      console.log('错误详情:', err.message, err.status);
      alert('退出分组失败: ' + (err && err.message ? err.message : '未知错误'));
    }
  }

  // 检查是否在广播页面
  function isBroadcastActive() {
    // 检查URL hash
    var currentHash = window.location.hash;
    var isBroadcastHash = currentHash === '#broadcast' || currentHash === '' || !currentHash;
    
    // 检查容器是否存在
    if (!container) return false;
    
    // 检查容器是否可见
    var isContainerVisible = container.classList.contains('is-active') || 
                            (container.classList.contains('view') && !container.classList.contains('is-hidden'));
    
    console.log('广播模块: 检查广播页面状态', {
      currentHash: currentHash,
      isBroadcastHash: isBroadcastHash,
      isContainerVisible: isContainerVisible,
      containerClass: container.className
    });
    
    return isBroadcastHash && isContainerVisible;
  }

  // 检查权限状态
  function checkAuthStatus() {
    var broadcastGuest = document.getElementById('broadcast-guest');
    var broadcastUser = document.getElementById('broadcast-user');
    console.log('权限状态检查:', {
      guest: broadcastGuest ? broadcastGuest.style.display : '未找到',
      user: broadcastUser ? broadcastUser.style.display : '未找到',
      guestHidden: broadcastGuest ? broadcastGuest.classList.contains('is-hidden') : '未找到',
      userHidden: broadcastUser ? broadcastUser.classList.contains('is-hidden') : '未找到'
    });
  }

  // 初始加载
  if (isBroadcastActive()) {
    console.log('广播模块: 页面已激活，开始加载分组');
    checkAuthStatus();
    
    // 强制显示用户界面（临时解决方案）
    var broadcastGuest = document.getElementById('broadcast-guest');
    var broadcastUser = document.getElementById('broadcast-user');
    if (broadcastGuest && broadcastUser) {
      broadcastGuest.style.display = 'none';
      broadcastUser.style.display = 'block';
      console.log('强制显示用户界面');
    }
    
    loadGroups();
    loadJoinedGroups();
  }

  // 监听页面切换
  document.addEventListener('click', function(e){
    var btn = e.target && (e.target.closest ? e.target.closest('.tab-btn') : null);
    if (btn && btn.getAttribute('data-target') === 'broadcast') {
      console.log('广播模块: 切换到广播页面，开始加载分组');
      loadGroups();
    }
  });

  // 监听页面显示事件
  document.addEventListener('DOMContentLoaded', function() {
    console.log('广播模块: DOM加载完成，检查广播页面状态');
    if (isBroadcastActive()) {
      loadGroups();
    }
  });

  // 强制初始化广播页面
  function forceInitBroadcast() {
    console.log('广播模块: 强制初始化广播页面');
    
    // 强制显示用户界面
    var broadcastGuest = document.getElementById('broadcast-guest');
    var broadcastUser = document.getElementById('broadcast-user');
    if (broadcastGuest && broadcastUser) {
      broadcastGuest.style.display = 'none';
      broadcastUser.style.display = 'block';
      console.log('广播模块: 强制显示用户界面');
    }
    
    // 强制加载数据
    setTimeout(function() {
      console.log('广播模块: 强制加载分组数据');
      loadGroups();
      loadJoinedGroups();
    }, 100);
  }

  // 暴露函数供外部调用
  window.broadcastManager = {
    loadGroups: loadGroups,
    loadJoinedGroups: loadJoinedGroups,
    forceInitBroadcast: forceInitBroadcast
  };

  console.log('广播模块: 初始化完成，已暴露broadcastManager');
})();


